home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / comm / mail / Mutt089src.lha / Mutt-0.89i-AMIGA / src / rx / rxnode.c < prev    next >
C/C++ Source or Header  |  1998-01-28  |  10KB  |  546 lines
  1. /* classes: src_files */
  2.  
  3. /*    Copyright (C) 1995, 1996 Tom Lord
  4.  * 
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU Library General Public License as published by
  7.  * the Free Software Foundation; either version 2, or (at your option)
  8.  * any later version.
  9.  * 
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU Library General Public License for more details.
  14.  * 
  15.  * You should have received a copy of the GNU Library General Public License
  16.  * along with this software; see the file COPYING.  If not, write to
  17.  * the Free Software Foundation, 59 Temple Place - Suite 330, 
  18.  * Boston, MA 02111-1307, USA. 
  19.  */
  20.  
  21.  
  22.  
  23. #include "rxall.h"
  24. #include "rxnode.h"
  25.  
  26.  
  27.  
  28. #define INITSIZE   8
  29. #define EXPANDSIZE 8
  30.  
  31. #ifdef __STDC__
  32. static int
  33. rx_init_string(struct rx_string *thisone, char first)
  34. #else
  35. static int
  36. rx_init_string(thisone, first)
  37.      struct rx_string *thisone;
  38.      char first;
  39. #endif
  40. {
  41.   char *tmp;
  42.  
  43.   tmp = (char *) malloc (INITSIZE);
  44.  
  45.   if(!tmp)
  46.     return -1;
  47.  
  48.   thisone->contents    = tmp;
  49.   thisone->contents[0] = first;
  50.   thisone->reallen     = INITSIZE;
  51.   thisone->len         = 1;
  52.   return 0;
  53. }
  54.  
  55. #ifdef __STDC__
  56. static void
  57. rx_free_string (struct rx_string *junk)
  58. #else
  59. static void
  60. rx_free_string (junk)
  61.      struct rx_string *junk;
  62. #endif
  63. {
  64.   free (junk->contents);
  65.   junk->len = junk->reallen = 0;
  66.   junk->contents = 0;
  67. }
  68.  
  69.  
  70. #ifdef __STDC__
  71. int
  72. rx_adjoin_string (struct rx_string *str, char c)
  73. #else
  74. int
  75. rx_adjoin_string (str, c)
  76.      struct rx_string *str;
  77.      char c;
  78. #endif
  79. {
  80.   if (!str->contents)
  81.     return rx_init_string (str, c);
  82.  
  83.   if (str->len == str->reallen)
  84.     {
  85.       char *temp;
  86.       temp = (char *) realloc (str->contents, str->reallen + EXPANDSIZE);
  87.  
  88.       if(!temp)
  89.     return -1;
  90.  
  91.       str->contents = temp;
  92.       str->reallen += EXPANDSIZE;
  93.     }
  94.  
  95.   str->contents[str->len++] = c;
  96.   return 0;
  97. }
  98.  
  99.  
  100. #ifdef __STDC__
  101. static int
  102. rx_copy_string (struct rx_string *to, struct rx_string *from)
  103. #else
  104. static int
  105. rx_copy_string (to, from)
  106.     struct rx_string *to;
  107.     struct rx_string *from;
  108. #endif
  109. {
  110.   char *tmp;
  111.  
  112.   if (from->len)
  113.     {
  114.       tmp = (char *) malloc (from->reallen);
  115.  
  116.       if (!tmp)
  117.     return -1;
  118.     }
  119.  
  120.   rx_free_string (to);
  121.   to->len      = from->len;
  122.   to->reallen  = from->reallen;
  123.   to->contents = tmp;
  124.  
  125.   memcpy (to->contents, from->contents, from->reallen);
  126.  
  127.   return 0;
  128. }
  129.  
  130.  
  131. #ifdef __STDC__
  132. static int
  133. rx_compare_rx_strings (struct rx_string *a, struct rx_string *b)
  134. #else
  135. static int
  136. rx_compare_rx_strings (a, b)
  137.      struct rx_string *a;
  138.      struct rx_string *b;
  139. #endif
  140. {
  141.   if (a->len != b->len)
  142.     return 0;
  143.  
  144.   if (a->len)
  145.     return !memcmp (a->contents, b->contents, a->len);
  146.   else
  147.     return 1;            /* trivial case: "" == "" */
  148. }
  149.  
  150.  
  151. #ifdef __STDC__
  152. static unsigned long
  153. rx_string_hash (unsigned long seed, struct rx_string *str)
  154. #else
  155. static unsigned long
  156. rx_string_hash (seed, str)
  157.      unsigned long seed;
  158.      struct rx_string *str;
  159. #endif
  160. {
  161.   /* From Tcl: */
  162.   unsigned long result;
  163.   int c;
  164.   char * string;
  165.   int len;
  166.  
  167.   string = str->contents;
  168.   len = str->len;
  169.   result = seed;
  170.  
  171.   while (len--)
  172.     {
  173.       c = *string;
  174.       string++;
  175.       result += (result<<3) + c;
  176.     }
  177.   return result;
  178. }
  179.  
  180.  
  181.  
  182.  
  183. #ifdef __STDC__
  184. struct rexp_node *
  185. rexp_node (int type)
  186. #else
  187. struct rexp_node *
  188. rexp_node (type)
  189.      int type;
  190. #endif
  191. {
  192.   struct rexp_node *n;
  193.  
  194.   n = (struct rexp_node *) malloc (sizeof (*n));
  195.   rx_bzero ((char *)n, sizeof (*n));
  196.   if (n)
  197.     {
  198.       n->type = type;
  199.       n->id = -1;
  200.       n->refs = 1;
  201.     }
  202.   return n;
  203. }
  204.  
  205.  
  206. /* free_rexp_node assumes that the bitset passed to rx_mk_r_cset
  207.  * can be freed using rx_free_cset.
  208.  */
  209.  
  210. #ifdef __STDC__
  211. struct rexp_node *
  212. rx_mk_r_cset (int type, int size, rx_Bitset b)
  213. #else
  214. struct rexp_node *
  215. rx_mk_r_cset (type, size, b)
  216.      int type;
  217.      int size;
  218.      rx_Bitset b;
  219. #endif
  220. {
  221.   struct rexp_node * n;
  222.   n = rexp_node (type);
  223.   if (n)
  224.     {
  225.       n->params.cset = b;
  226.       n->params.cset_size = size;
  227.     }
  228.   return n;
  229. }
  230.  
  231.  
  232. #ifdef __STDC__
  233. struct rexp_node *
  234. rx_mk_r_int (int type, int intval)
  235. #else
  236. struct rexp_node *
  237. rx_mk_r_int (type, intval)
  238.      int type;
  239.      int intval;
  240. #endif
  241. {
  242.   struct rexp_node * n;
  243.   n = rexp_node (type);
  244.   if (n)
  245.     n->params.intval = intval;
  246.   return n;
  247. }
  248.  
  249.  
  250. #ifdef __STDC__
  251. struct rexp_node *
  252. rx_mk_r_str (int type, char c)
  253. #else
  254. struct rexp_node *
  255. rx_mk_r_str (type, c)
  256.      int type;
  257.      char c;
  258. #endif
  259. {
  260.   struct rexp_node *n;
  261.   n = rexp_node (type);
  262.   if (n)
  263.     rx_init_string (&(n->params.cstr), c);
  264.   return n;
  265. }
  266.  
  267.  
  268. #ifdef __STDC__
  269. struct rexp_node *
  270. rx_mk_r_binop (int type, struct rexp_node * a, struct rexp_node * b)
  271. #else
  272. struct rexp_node *
  273. rx_mk_r_binop (type, a, b)
  274.      int type;
  275.      struct rexp_node * a;
  276.      struct rexp_node * b;
  277. #endif
  278. {
  279.   struct rexp_node * n = rexp_node (type);
  280.   if (n)
  281.     {
  282.       n->params.pair.left = a;
  283.       n->params.pair.right = b;
  284.     }
  285.   return n;
  286. }
  287.  
  288.  
  289. #ifdef __STDC__
  290. struct rexp_node *
  291. rx_mk_r_monop (int type, struct rexp_node * a)
  292. #else
  293. struct rexp_node *
  294. rx_mk_r_monop (type, a)
  295.      int type;
  296.      struct rexp_node * a;
  297. #endif
  298. {
  299.   return rx_mk_r_binop (type, a, 0);
  300. }
  301.  
  302.  
  303. #ifdef __STDC__
  304. void
  305. rx_free_rexp (struct rexp_node * node)
  306. #else
  307. void
  308. rx_free_rexp (node)
  309.      struct rexp_node * node;
  310. #endif
  311. {
  312.   if (node && !--node->refs)
  313.     {
  314.       if (node->params.cset)
  315.     rx_free_cset (node->params.cset);
  316.       if (node->params.cstr.reallen)
  317.     rx_free_string (&(node->params.cstr));
  318.       rx_free_rexp (node->params.pair.left);
  319.       rx_free_rexp (node->params.pair.right);
  320.       rx_free_rexp (node->simplified);
  321.       free ((char *)node);
  322.     }
  323. }
  324.  
  325. #ifdef __STDC__
  326. void
  327. rx_save_rexp (struct rexp_node * node)
  328. #else
  329. void
  330. rx_save_rexp (node)
  331.      struct rexp_node * node;
  332. #endif
  333. {
  334.   if (node)
  335.     ++node->refs;
  336. }
  337.  
  338.  
  339. #ifdef __STDC__
  340. struct rexp_node * 
  341. rx_copy_rexp (int cset_size, struct rexp_node *node)
  342. #else
  343. struct rexp_node * 
  344. rx_copy_rexp (cset_size, node)
  345.      int cset_size;
  346.      struct rexp_node *node;
  347. #endif
  348. {
  349.   if (!node)
  350.     return 0;
  351.   else
  352.     {
  353.       struct rexp_node *n;
  354.       n = rexp_node (node->type);
  355.       if (!n)
  356.     return 0;
  357.  
  358.       if (node->params.cset)
  359.     {
  360.       n->params.cset = rx_copy_cset (cset_size,
  361.                      node->params.cset);
  362.       if (!n->params.cset)
  363.         {
  364.           rx_free_rexp (n);
  365.           return 0;
  366.         }
  367.     }
  368.  
  369.       if (node->params.cstr.reallen)
  370.     if (rx_copy_string (&(n->params.cstr), &(node->params.cstr)))
  371.       {
  372.         rx_free_rexp(n);
  373.         return 0;
  374.       }
  375.  
  376.       n->params.intval = node->params.intval;
  377.       n->params.intval2 = node->params.intval2;
  378.       n->params.pair.left = rx_copy_rexp (cset_size, node->params.pair.left);
  379.       n->params.pair.right = rx_copy_rexp (cset_size, node->params.pair.right);
  380.       if (   (node->params.pair.left && !n->params.pair.left)
  381.       || (node->params.pair.right && !n->params.pair.right))
  382.     {
  383.       rx_free_rexp  (n);
  384.       return 0;
  385.     }
  386.       n->id = node->id;
  387.       n->len = node->len;
  388.       n->observed = node->observed;
  389.       return n;
  390.     }
  391. }
  392.  
  393.  
  394.  
  395. #ifdef __STDC__
  396. struct rexp_node * 
  397. rx_shallow_copy_rexp (int cset_size, struct rexp_node *node)
  398. #else
  399. struct rexp_node * 
  400. rx_shallow_copy_rexp (cset_size, node)
  401.      int cset_size;
  402.      struct rexp_node *node;
  403. #endif
  404. {
  405.   if (!node)
  406.     return 0;
  407.   else
  408.     {
  409.       struct rexp_node *n;
  410.       n = rexp_node (node->type);
  411.       if (!n)
  412.     return 0;
  413.  
  414.       if (node->params.cset)
  415.     {
  416.       n->params.cset = rx_copy_cset (cset_size,
  417.                      node->params.cset);
  418.       if (!n->params.cset)
  419.         {
  420.           rx_free_rexp (n);
  421.           return 0;
  422.         }
  423.     }
  424.  
  425.       if (node->params.cstr.reallen)
  426.     if (rx_copy_string (&(n->params.cstr), &(node->params.cstr)))
  427.       {
  428.         rx_free_rexp(n);
  429.         return 0;
  430.       }
  431.  
  432.       n->params.intval = node->params.intval;
  433.       n->params.intval2 = node->params.intval2;
  434.       n->params.pair.left = node->params.pair.left;
  435.       rx_save_rexp (node->params.pair.left);
  436.       n->params.pair.right = node->params.pair.right;
  437.       rx_save_rexp (node->params.pair.right);
  438.       n->id = node->id;
  439.       n->len = node->len;
  440.       n->observed = node->observed;
  441.       return n;
  442.     }
  443. }
  444.  
  445.  
  446.  
  447.  
  448. #ifdef __STD